As should be appreciated, a virtual machine (‘VM’) within the context of emulation is a software construct or the like operating on a computing device or the like (i.e., a ‘host’) for the purpose of emulating a hardware or software system. Typically, although not necessarily, the VM is an application or the like, and may be employed on the host to instantiate a use application or the like while at the same time isolating such use application from such host device or from other applications on such host. In one typical situation, the host can accommodate one deployed VM or more than one deployed VM, each VM performing some predetermined function by way of resources available from the host.
Typically, although not necessarily, a host deploys each VM thereof in a separate partition. Such host may include a virtualization or emulation layer with an emulator or the like (hereinafter, ‘emulator’) that oversees each VM and thus manages supervisory aspects of each VM of the host, as well as acting as a link between each VM and the outside world.
Also typically, each use application executing within each VM is fully virtualized in that the VM is for all intents and purposes a computing machine, although in virtual form, and thus represents itself as such both to the use application thereof and to the outside world. In fact, such a fully virtualized use application is not even aware of the virtual form of its execution environment but instead presumes that such execution environment is indeed an actual computing device with hardware and software. Thus, any command issued from the use application with regard to hardware, such as a storage command, a network command, a print command, etc., is issued as if directed toward the corresponding piece of hardware, but in reality is directed toward a virtual representation of such corresponding piece of hardware. Accordingly, any such command must be intercepted by the emulator on the computing device and then must be redirected toward the actual corresponding piece of hardware on the computing device.
In general then, full or traditional virtualization focuses on creating a ‘hermetic sandbox’ in which an emulated guest executes. Said guest exists in an isolated state, with no ability of (directly) affecting any hardware outside the sandbox. Thus, the guest within a fully virtualizing VM operates under the illusion that it executes directly on a real hardware device. The sandboxing of the guest protects the host computing device from any accidental or intentional action performed by the guest from adversely affecting the host environment. Also, by having each guest within a corresponding hermetic sandbox, the host can instantiate any number of guests in independent sandboxes, and each guest can effectuate hardware services at the host by way of the emulator intercepting each request for such a hardware service and handling same on behalf of such requestor in a coordinated fashion such that multiple guests coexist within a single host.
However, full virtualization as implemented by a classic VM exacts a cost in that every such hardware request as intercepted in effect requires double processing, first by the guest within the VM and then by the emulator within the host. As a result, processing of such hardware requests is slowed, and functions requiring high speed may suffer from delays, resulting in the guest experiencing reduced emulation performance. As may be appreciated, such delays can be merely annoying or can in fact be crippling, depending on the nature of the guest and the tasks being performed thereby.
Thus, a need exists for a virtualization model that does not necessarily require double processing of each hardware request from a guest, first by the guest's own operating system and drivers within the VM and then by an emulator within a host. Instead, a need exists for a virtualization model that allows the guest to bypass the emulator in at least some circumstances and issue hardware requests directly to the host operating system or to the actual host hardware. In particular, a need exists for a partial virtualization model where a partially virtualized guest is aware of the virtual form of its environment and directs at least some hardware requests through a route that bypasses the emulator.